package Serveur;

import java.util.ArrayList;
import java.util.HashMap;

import Carte.Trajet;
import Carte.Ville;

/**
 * Cette classe permet de creer des Noeuds qui serviront a effectuer des
 * recherches pour aller d'une ville A à une ville B utilisant une succession de
 * transport
 * 
 * @author Jeremie
 * 
 */

public class Noeud {
    // la ville du noeud chaque noeud est caracterisé par une seule ville
    Ville villeCourante;
    
    // la liste des destinations ou l'on peut se rendre en un seul trajet a
    // partir de la villeCourante
    ArrayList<Noeud> listNoeud;
    
    // une HashMap qui contient toutes les villes d'origine qui nous ont permis
    // de rejoindre la villeCourante ainsi
    // que le moyen de transport utilisé
    HashMap<Noeud, Trajet> listParent;
    
    // le Noeud parent sert pour retracer le chemin
    Noeud parent;
    
    // le temp total mis pour arrivé a la villeCourante
    int time;
    
    // le nombre total de deplacement utilisé
    int nbDeplacement;

    /**
     * Constructeur normal
     * 
     * @param ville
     *            v
     * @param trajet
     *            pour arrive a la ville v
     * @param parent
     *            : ville d'ou on vient
     */

    public Noeud(Ville v, Trajet t, Noeud parent) {
        this.villeCourante = v;
        this.listNoeud = new ArrayList<Noeud>();
        this.listParent = new HashMap<Noeud, Trajet>();
        if (parent != null) {
            parent.ajouterNoeud(this, t);
        }
        if (t != null) {
            time = t.getTime();
        } else {
            time = 0;
        }
        nbDeplacement = 1;
    }

    public Noeud getParent() {
        return parent;
    }

    public int getNbDeplacement() {
        return nbDeplacement;
    }

    public int getTime() {
        return time;
    }

    public void setTime(int t) {
        time += t;
    }

    public void setTrajet(Noeud noeudParent, Trajet t) {
        listParent.put(noeudParent, t);
    }

    public void ajouterNoeud(Noeud noeudFils, Trajet t) {
        listNoeud.add(noeudFils);
        noeudFils.setTrajet(this, t);
    }

    public Ville getVille() {
        return villeCourante;
    }

    public Trajet getTrajet(Noeud n) {
        return listParent.get(n);
    }

    public ArrayList<Noeud> getListNoeud() {
        return listNoeud;
    }

    /**
     * Rechercher si une ville est presente dans le reseau a partir du noeud courant
     * 
     * @param ville
     *            v : ville recherche
     * @return boolean
     */

    public boolean villePresente(Ville v) {
        // on parcourt la liste des destinations du noeudCourant recursivement
        // jusqu'a trouver la ville cherche sauf si innexistante
        for (int i = 0; i < this.getListNoeud().size(); i++) {
            if (this.getListNoeud().get(i).getVille().equals(v)) {
                return true;
            } else {
                if (this.getListNoeud().get(i).villePresente(v)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Recherche un Noeud avec pour ville la ville v a partir du noeud courant
     * 
     * @param ville
     *            v : ville recherche
     * @return Noeud
     */
	public Noeud getNoeud(Ville v) {
        Noeud temp;
        // on parcourt la liste des destinations du noeudCourant jusqu'a trouver
        // le noeud de la ville v
        temp = this.getListNoeud().get(0);
        if(temp.getVille().equals(v)) {
            return temp;
        } 
        else{
        	int i = 0;
        	Noeud noeudBoucle = null;
        	while(noeudBoucle == null || this.getListNoeud().size() < i){
        		noeudBoucle = this.getListNoeud().get(i).getNoeud(v); 
        		i++;
        	}
        	return noeudBoucle;
        }
    }

}
